Skip Headers

Oracle® Database SQL Reference 10g Release 2 (10.2) Part Number B14200-02 |
Home | Book List | Contents | Index | Master Index | Feedback

Previous | Next
| View PDF

# CREATE JAVA

Purpose

Use the `CREATE` `JAVA` statement to create a schema object containing a Java source, class, or resource.

See Also: Oracle Database Java Developer's Guide for Java concepts Oracle Database Java Developer's Guide for Java stored procedures Oracle Database JDBC Developer's Guide and Reference for information on JDBC

Prerequisites

To create or replace a schema object containing a Java source, class, or resource in your own schema, you must have `CREATE` `PROCEDURE` system privilege. To create such a schema object in another user's schema, you must have `CREATE` `ANY` `PROCEDURE` system privilege. To replace such a schema object in another user's schema, you must also have `ALTER` `ANY` `PROCEDURE` system privilege.

Syntax

create_java::=

Description of the illustration create_java.gif

invoker_rights_clause::=

Description of the illustration invoker_rights_clause.gif

Semantics

OR REPLACE

Specify `OR` `REPLACE` to re-create the schema object containing the Java class, source, or resource if it already exists. Use this clause to change the definition of an existing object without dropping, re-creating, and regranting object privileges previously granted.

If you redefine a Java schema object and specify `RESOLVE` or `COMPILE`, then Oracle Database recompiles or resolves the object. Whether or not the resolution or compilation is successful, the database invalidates classes that reference the Java schema object.

Users who had previously been granted privileges on a redefined function can still access the function without being regranted the privileges.

See Also: ALTER JAVA for additional information

RESOLVE | COMPILE

`RESOLVE` and `COMPILE` are synonymous keywords. They specify that Oracle Database should attempt to resolve the Java schema object that is created if this statement succeeds.

- When applied to a class, resolution of referenced names to other class schema objects occurs.

- When applied to a source, source compilation occurs.

Restriction on RESOLVE and COMPILE You cannot specify these keywords for a Java resource.

NOFORCE

Specify `NOFORCE` to roll back the results of this `CREATE` command if you have specified either `RESOLVE` or `COMPILE` and the resolution or compilation fails. If you do not specify this option, then Oracle Database takes no action if the resolution or compilation fails. That is, the created schema object remains.

JAVA SOURCE Clause

Specify `JAVA` `SOURCE` to load a Java source file.

JAVA CLASS Clause

Specify `JAVA` `CLASS` to load a Java class file.

JAVA RESOURCE Clause

Specify `JAVA` `RESOURCE` to load a Java resource file.

NAMED Clause

The `NAMED` clause is required for a Java source or resource. The `primary_name` must be enclosed in double quotation marks.

- For a Java source, this clause specifies the name of the schema object in which the source code is held. A successful `CREATE` `JAVA` `SOURCE` statement will also create additional schema objects to hold each of the Java classes defined by the source.

- For a Java resource, this clause specifies the name of the schema object to hold the Java resource.

Use double quotation marks to preserve a lower- or mixed-case `primary_name`.

If you do not specify `schema`, then Oracle Database creates the object in your own schema.

Restrictions on NAMED Java Classes The `NAMED` clause is subject to the following restrictions:

- You cannot specify `NAMED` for a Java class.

- The `primary_name` cannot contain a database link.

SCHEMA Clause

The `SCHEMA` clause applies only to a Java class. This optional clause specifies the schema in which the object containing the Java file will reside. If you do not specify this clause, then Oracle Database creates the object in your own schema.

invoker_rights_clause

Use the `invoker_rights_clause` to indicate whether the methods of the class execute with the privileges and in the schema of the user who owns the class or with the privileges and in the schema of `CURRENT_USER`.

This clause also determines how Oracle Database resolves external names in queries, DML operations, and dynamic SQL statements in the member functions and procedures of the type.

AUTHID CURRENT_USER

`CURRENT_USER` indicates that the methods of the class execute with the privileges of `CURRENT_USER`. This clause is the default and creates an invoker-rights class.

This clause also specifies that external names in queries, DML operations, and dynamic SQL statements resolve in the schema of `CURRENT_USER`. External names in all other statements resolve in the schema in which the methods reside.

AUTHID DEFINER

`DEFINER` indicates that the methods of the class execute with the privileges of the owner of the schema in which the class resides, and that external names resolve in the schema where the class resides. This clause creates a definer-rights class.

See Also: Oracle Database Java Developer's Guide Oracle Database Concepts and Oracle Database Application Developer's Guide - Fundamentals for information on how `CURRENT_USER` is determined

RESOLVER Clause

The `RESOLVER` clause lets you specify a mapping of the fully qualified Java name to a Java schema object, where:

- `match_string` is either a fully qualified Java name, a wildcard that can match such a Java name, or a wildcard that can match any name.

- `schema_name` designates a schema to be searched for the corresponding Java schema object.

- A dash (-) as an alternative to `schema_name` indicates that if `match_string` matches a valid Java name, Oracle Database can leave the name unresolved. The resolution succeeds, but the name cannot be used at run time by the class.

This mapping is stored with the definition of the schema objects created in this command for use in later resolutions (either implicit or in explicit `ALTER` `JAVA` ... `RESOLVE` statements).

USING Clause

The `USING` clause determines a sequence of character data (`CLOB` or `BFILE`) or binary data (`BLOB` or `BFILE`) for the Java class or resource. Oracle Database uses the sequence of characters to define one file for a Java class or resource, or one source file and one or more derived classes for a Java source.

BFILE Clause

Specify the directory and filename of a previously created file on the operating system (`directory_object_name`) and server file (`server_file_name`) containing the sequence. `BFILE` is usually interpreted as a character sequence by `CREATE` `JAVA` `SOURCE` and as a binary sequence by `CREATE` `JAVA` `CLASS` or `CREATE` `JAVA` `RESOURCE`.

CLOB | BLOB | BFILE subquery

Specify a subquery that selects a single row and column of the type specified (`CLOB`, `BLOB`, or `BFILE`). The value of the column makes up the sequence of characters.

Note: In earlier releases, the `USING` clause implicitly supplied the keyword `SELECT`. This is no longer the case. However, the subquery without the keyword `SELECT` is still supported for backward compatibility.

key_for_BLOB

The `key_for_BLOB` clause supplies the following implicit query:

    SELECT LOB FROM CREATE$JAVA$LOB$TABLE
       WHERE NAME = 'key_for_BLOB';

Restriction on the key_for_BLOB Clause For you to use this case, the table `CREATE$JAVA$LOB$TABLE` must exist in the current schema and must have a column LOB of type `BLOB` and a column `NAME` of type `VARCHAR2`.

AS source_char

Specify a sequence of characters for a Java source.

Examples

Creating a Java Class Object: Example The following statement creates a schema object containing a Java class using the name found in a Java binary file:

    CREATE JAVA CLASS USING BFILE (java_dir, 'Agent.class')
    /

This example assumes the directory object `java_dir`, which points to the operating system directory containing the Java class `Agent.class`, already exists. In this example, the name of the class determines the name of the Java class schema object.

Creating a Java Source Object: Example The following statement creates a Java source schema object:

    CREATE JAVA SOURCE NAMED "Welcome" AS
       public class Welcome {
          public static String welcome() {
             return "Welcome World";   } }
    /

Creating a Java Resource Object: Example The following statement creates a Java resource schema object named `apptext` from a `bfile`:

    CREATE JAVA RESOURCE NAMED "appText"
       USING BFILE (java_dir, 'textBundle.dat')
    /